{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPO_Pendulum-v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义参数\n",
    "\n",
    "为方便实验调试，把所有参数都放在一起"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.env_id = \"Pendulum-v1\"\n",
    "        self.n_workers = 10 # 多进程env数\n",
    "        self.max_frames = 1000000\n",
    "        self.seed = 1\n",
    "        self.hidden_dim = 256\n",
    "        self.lr = 3e-4\n",
    "        self.n_steps = 200\n",
    "        self.mini_batch_size = 50\n",
    "        self.n_epochs = 4\n",
    "        self.threshold_reward = -200\n",
    "        self.clip_param = 0.2\n",
    "        self.gamma = 0.99\n",
    "        self.tau = 0.95\n",
    "        self.device = self._auto_get_device() # 设备\n",
    "    \n",
    "    def _auto_get_device(self):\n",
    "        _device = 'cpu'\n",
    "        if torch.cuda.is_available():\n",
    "            _device = 'cuda'\n",
    "        elif torch.backends.mps.is_available():\n",
    "            _device = 'mps'\n",
    "        return _device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim, hidden_dim, std=0.0):\n",
    "        super(Model, self).__init__()\n",
    "        \n",
    "        self.critic = nn.Sequential(\n",
    "            nn.Linear(input_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            # nn.Linear(hidden_dim, hidden_dim),\n",
    "            # nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, 1)\n",
    "        )\n",
    "        \n",
    "        self.actor = nn.Sequential(\n",
    "            nn.Linear(input_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            # nn.Linear(hidden_dim, hidden_dim),\n",
    "            # nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, output_dim),\n",
    "        )\n",
    "        self.log_std = nn.Parameter(torch.ones(1, output_dim) * std)\n",
    "        \n",
    "        # self.apply(init_linear_weights)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        value = self.critic(x)\n",
    "        mu = self.actor(x)\n",
    "        mu = torch.tanh(mu)\n",
    "        std = self.log_std.exp().expand_as(mu)\n",
    "        return mu, std, value\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "\n",
    "class Exp:\n",
    "    def __init__(self, **kwargs):\n",
    "        for k, v in kwargs.items():\n",
    "            setattr(self, k, v)\n",
    "        # self.__dict__.update(kwargs)\n",
    "\n",
    "\n",
    "class ReplayBuffer:\n",
    "    '''replay buffer for policy gradient based methods, each time these methods will sample all transitions\n",
    "    Args:\n",
    "        ReplayBufferQue (_type_): _description_\n",
    "    '''\n",
    "    def __init__(self, cfg: Config):\n",
    "        self.cfg = cfg\n",
    "        self.buffer = deque(maxlen=1)\n",
    "        self.batch_exps = []\n",
    "\n",
    "    def push(self, exps: list[Exp]):\n",
    "        self.batch_exps.extend(exps)\n",
    "        if len(self.batch_exps) >= self.cfg.batch_size:\n",
    "            self.buffer.append(self.batch_exps)\n",
    "            self.batch_exps = []\n",
    "\n",
    "    def sample(self, **kwargs):\n",
    "        ''' sample all the transitions\n",
    "        '''\n",
    "        if len(self.buffer) == 0: return None\n",
    "        batch = self.buffer.pop()\n",
    "        # batch = list(self.buffer)\n",
    "        # self.buffer.clear() # on policy buffer will clear the buffer after sampling\n",
    "        return batch\n",
    "    \n",
    "    def clear(self):\n",
    "        ''' clear the buffer\n",
    "        '''\n",
    "        self.buffer.clear()\n",
    "\n",
    "    def __len__(self):\n",
    "        ''' return the current size of the buffer\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import numpy as np\n",
    "import torch.optim as optim\n",
    "from torch.distributions import Normal\n",
    "\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self, cfg: Config, state_dim: int, action_dim:int):\n",
    "        self.gamma = cfg.gamma\n",
    "        self.tau = cfg.tau\n",
    "        self.n_epochs = cfg.n_epochs\n",
    "        self.mini_batch_size = cfg.mini_batch_size\n",
    "        self.clip_param = cfg.clip_param\n",
    "        self.device = torch.device(cfg.device)\n",
    "\n",
    "        self.model = Model(state_dim, action_dim, cfg.hidden_dim)\n",
    "        self.optimizer = optim.Adam(self.model.parameters(), lr=cfg.lr)\n",
    "        \n",
    "        self.policy_transition = {}\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def sample_action(self, state):\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        mean, std, _ = self.model(state)\n",
    "        dist = Normal(mean, std)\n",
    "        z = dist.sample()\n",
    "        action = torch.tanh(z)\n",
    "        log_prob = dist.log_prob(action) + torch.log(1 - action.pow(2) + 1e-6) # 增加一个小的常数，避免log(0)\n",
    "        action = action.detach().cpu().numpy()\n",
    "        self.policy_transition['log_prob'] = log_prob.cpu().numpy().item()\n",
    "        return action[0]\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        mean, _, _ = self.model(state)\n",
    "        action = mean.cpu().numpy()\n",
    "        return action[0]\n",
    "    \n",
    "    @staticmethod\n",
    "    def ppo_iter(mini_batch_size, states, actions, log_probs, returns, advantage):\n",
    "        batch_size = states.size(0)\n",
    "        for _ in range(batch_size // mini_batch_size):\n",
    "            rand_ids = np.random.randint(0, batch_size, mini_batch_size)\n",
    "            yield states[rand_ids, :], actions[rand_ids, :], log_probs[rand_ids, :], returns[rand_ids, :], advantage[rand_ids, :]\n",
    "            \n",
    "    def compute_return_mc(self, rewards, masks):\n",
    "        returns = []\n",
    "        discounted_return = 0\n",
    "        for step in reversed(range(len(rewards))):\n",
    "            discounted_return = rewards[step] + self.gamma * discounted_return * masks[step]\n",
    "            returns.insert(0, discounted_return)\n",
    "        # normalize can help to stabilize training\n",
    "        normed_returns = []\n",
    "        for ret in returns:\n",
    "            normed_returns.append((ret - ret.mean()) / (ret.std() + 1e-5))\n",
    "        return normed_returns\n",
    "         \n",
    "    def compute_advantage_td(self, rewards, masks, values):\n",
    "        returns = []\n",
    "        discounted_return = values[-1].detach()\n",
    "        for step in reversed(range(len(rewards))):\n",
    "            discounted_return = rewards[step] + self.gamma * discounted_return * masks[step]\n",
    "            returns.insert(0, discounted_return)\n",
    "        normed_returns = []\n",
    "        for ret in returns:\n",
    "            normed_returns.append((ret - ret.mean()) / (ret.std() + 1e-5))\n",
    "        return normed_returns\n",
    "\n",
    "    def compute_advantage_gae(self, next_value, rewards, masks, values):\n",
    "        # next_value = values[-1]\n",
    "        gae = 0\n",
    "        returns = []\n",
    "        for step in reversed(range(len(rewards))):\n",
    "            delta = rewards[step] + self.gamma * next_value * masks[step] - values[step]\n",
    "            gae = delta + self.gamma * self.tau * masks[step] * gae\n",
    "            returns.insert(0, gae + values[step])\n",
    "            next_value = values[step]\n",
    "        normed_returns = []\n",
    "        for ret in returns:\n",
    "            normed_returns.append((ret - ret.mean()) / (ret.std() + 1e-5))\n",
    "        return normed_returns\n",
    "    \n",
    "    def learn(self, **kwargs):\n",
    "        states, actions, log_probs, returns, advantages = kwargs['states'], kwargs['actions'], kwargs['log_probs'], kwargs['returns'], kwargs['advantages']\n",
    "        actor_loss_epoch, critic_loss_epoch = [], []\n",
    "        for _ in range(self.n_epochs):\n",
    "            for state, action, old_log_probs, return_, advantage in self.ppo_iter(self.mini_batch_size, states, actions, log_probs, returns, advantages):\n",
    "                mu, std, value = self.model(state)\n",
    "                mu = mu * self.action_scale + self.action_bias\n",
    "                dist = Normal(mu, std)\n",
    "                entropy = dist.entropy().mean()\n",
    "                new_log_probs = dist.log_prob(action)\n",
    "\n",
    "                ratio = (new_log_probs - old_log_probs).exp()\n",
    "                surr1 = ratio * advantage\n",
    "                surr2 = torch.clamp(ratio, 1.0 - self.clip_param, 1.0 + self.clip_param) * advantage\n",
    "\n",
    "                actor_loss  = - torch.min(surr1, surr2).mean()\n",
    "                critic_loss = (return_ - value).pow(2).mean()\n",
    "\n",
    "                actor_loss_epoch.append(actor_loss.item())\n",
    "                critic_loss_epoch.append(critic_loss.item())\n",
    "\n",
    "                loss = 0.5 * critic_loss + actor_loss - 0.001 * entropy\n",
    "                \n",
    "                self.optimizer.zero_grad()\n",
    "                loss.backward()\n",
    "                for param in self.model.parameters():\n",
    "                    param.grad.data.clamp_(-1, 1)\n",
    "                self.optimizer.step()\n",
    "        return np.mean(actor_loss_epoch), np.mean(critic_loss_epoch) \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ray\n",
    "import gymnasium as gym\n",
    "\n",
    "def compute_returns_for_exps(exps, gamma=0.95, gae_lambda=0.95):\n",
    "    ''' 计算return，包括MC, TD, GAE\n",
    "    '''\n",
    "    def _get_exp_len(exps, max_step: int = 1):\n",
    "        ''' get exp len\n",
    "        '''\n",
    "        exp_len = len(exps)\n",
    "        if exp_len <= max_step or exps[-1].done:\n",
    "            exp_len = max(exp_len, 0)\n",
    "        else:\n",
    "            exp_len = exp_len - max_step\n",
    "        return exp_len\n",
    "    exp_len = _get_exp_len(exps)\n",
    "    next_value = exps[-1].value\n",
    "    return_mc = 0\n",
    "    return_td = next_value   \n",
    "    adv_gae = 0\n",
    "    returns_mc = []\n",
    "    returns_td = []\n",
    "    returns_gae = []\n",
    "    for t in reversed(range(exp_len)):\n",
    "        delta = exps[t].reward + gamma * next_value * (1 - exps[t].done) - exps[t].value\n",
    "        adv_gae = delta + gamma * gae_lambda * (1 - exps[t].done) * adv_gae\n",
    "        return_mc = exps[t].reward + gamma * return_mc * (1 - exps[t].done)\n",
    "        return_td = exps[t].reward + gamma * return_td * (1 - exps[t].done)\n",
    "        returns_mc.insert(0, return_mc)\n",
    "        returns_td.insert(0, return_td)\n",
    "        returns_gae.insert(0, adv_gae + exps[t].value)\n",
    "        exps[t].return_mc = return_mc\n",
    "        exps[t].return_td = return_td\n",
    "        exps[t].adv_gae = adv_gae\n",
    "        exps[t].return_gae = adv_gae + exps[t].value\n",
    "        next_value = exps[t].value\n",
    "    return_mc_normed = (returns_mc - np.mean(returns_mc)) / (np.std(returns_mc) + 1e-8)\n",
    "    return_td_normed = (returns_td - np.mean(returns_td)) / (np.std(returns_td) + 1e-8)\n",
    "    return_gae_normed = (returns_gae - np.mean(returns_gae)) / (np.std(returns_gae) + 1e-8)\n",
    "    for t in range(exp_len):\n",
    "        exps[t].return_mc_normed = return_mc_normed[t]\n",
    "        exps[t].return_td_normed = return_td_normed[t]\n",
    "        exps[t].return_gae_normed = return_gae_normed[t]\n",
    "    exps = exps[:exp_len]\n",
    "    return exps\n",
    "\n",
    "class NormalizedActions(gym.ActionWrapper):\n",
    "    ''' 由于网络输出的动作范围是[-1, 1]，而环境接收的动作范围可能是[-2,2]这种非标准化的范围，所以需要对动作进行归一化\n",
    "        也可以在Policy中进行进行action的scale和bias，但是相对来说会麻烦些\n",
    "    '''\n",
    "    def action(self, action):\n",
    "        low  = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "        \n",
    "        action = low + (action + 1.0) * 0.5 * (high - low)\n",
    "        action = np.clip(action, low, high)\n",
    "        \n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action):\n",
    "        low  = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "        action = 2 * (action - low) / (high - low) - 1\n",
    "        action = np.clip(action, low, high)\n",
    "        return action\n",
    "    \n",
    "@ray.remote\n",
    "class Interactor:\n",
    "    ''' 多进程worker\n",
    "    '''\n",
    "    def __init__(self, cfg, idx, **kwargs):\n",
    "        if not ray.is_initialized():\n",
    "            ray.init(ignore_reinit_error=True)\n",
    "        self.cfg = cfg\n",
    "        self.idx = idx\n",
    "        self.env = NormalizedActions(gym.make(cfg.env_id))\n",
    "        self.seed = cfg.seed + idx\n",
    "        self.state, _  = self.env.reset(seed=self.seed)\n",
    "\n",
    "    def run(self, policy):\n",
    "        exps = []\n",
    "        for _ in range(self.cfg.n_steps):\n",
    "            action = policy.sample_action(self.state)\n",
    "            next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "            done = terminated or truncated\n",
    "            policy_transition = policy.get_policy_transition()\n",
    "            interact_transition = {'state':self.state, 'action':action, 'reward':reward, 'next_state':next_state, 'done':done}\n",
    "            exps.append(Exp(**interact_transition, **policy_transition))\n",
    "            self.state = next_state\n",
    "            if done:\n",
    "                self.state, _ = self.env.reset(seed=self.seed)\n",
    "        exps = compute_returns_for_exps(exps, self.cfg.gamma, self.cfg.tau)\n",
    "        return exps\n",
    "    \n",
    "    @property\n",
    "    def action_dim(self):\n",
    "        return self.env.action_space.shape[0] # 动作空间的维度\n",
    "    @property\n",
    "    def state_dim(self):\n",
    "        return self.env.observation_space.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def eval_policy(cfg: Config, policy: Policy, env):\n",
    "    ''' 测试\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []  # 记录所有回合的步数\n",
    "    for i_ep in range(cfg.online_eval_episode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, _ = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            action = policy.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , _ = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            ep_step += 1\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        steps.append(ep_step)\n",
    "    \n",
    "    return {'reward': np.mean(rewards), 'step': np.mean(steps)}\n",
    "\n",
    "def train(cfg: Config):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env_workers = [EnvWorker.remote(cfg, idx) for idx in range(cfg.n_envs)]\n",
    "    eval_env = NormalizedActions(gym.make(cfg.env_id))\n",
    "    policy = Policy(cfg, env_workers[0].state_dim, env_workers[0].action_dim)\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    eval_rewards = []  # 记录所有回合的奖励\n",
    "    best_policy_params = None  # 最佳策略\n",
    "    best_ep_reward = float('-inf') # 最佳回合的奖励\n",
    "    tot_step = 0\n",
    "    policy_summary_dict = {} # 记录策略更新的参数，如损失等\n",
    "    for i_ep in range(cfg.max_epsiode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, _ = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            ep_step += 1\n",
    "            tot_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , _ = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated or truncated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            # 更新智能体，这里也可以改成每采样50步再更新50次\n",
    "            policy_summary = policy.update()  \n",
    "            if policy_summary is not None:\n",
    "                for k, v in policy_summary.items():\n",
    "                    if k not in policy_summary_dict:\n",
    "                        policy_summary_dict[k] = []\n",
    "                    policy_summary_dict[k].append(v)\n",
    "                if policy.update_cnt > 0 and policy.update_cnt % cfg.online_eval_freq == 0:\n",
    "                    eval_res = eval_policy(cfg, policy, eval_env)\n",
    "                    eval_rewards.append(eval_res['reward'])\n",
    "                    if eval_res['reward'] >= best_ep_reward:\n",
    "                        print(f\"找到新的最优策略，回合：{i_ep+1}，模型步数：{policy.update_cnt}，测试奖励：{eval_res['reward']:.2f}, 测试回合长度：{eval_res['step']}\")\n",
    "                        best_ep_reward = eval_res['reward']\n",
    "                        best_policy_params = policy.get_policy_params()\n",
    "            # policy.update() \n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}，回合长度：{ep_step}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'eval_rewards':eval_rewards, 'policy_summary_dict':policy_summary_dict,'best_policy_params':best_policy_params}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def evaluate_policy(env, policy, vis=False):\n",
    "    state,_ = env.reset()\n",
    "    if vis: env.render()\n",
    "    terminated = False\n",
    "    total_reward = 0\n",
    "    while True:\n",
    "        action, _, _ = policy.get_action(np.array(state).reshape(1, -1))\n",
    "        next_state, reward, terminated, truncated , _ = env.step(action[0])\n",
    "        state = next_state\n",
    "        # if vis: env.render()\n",
    "        total_reward += reward\n",
    "        if truncated:\n",
    "            break\n",
    "    \n",
    "    return total_reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.env_id = \"Pendulum-v1\"\n",
    "        self.n_envs = 10\n",
    "        self.device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        self.max_frames = 1000000\n",
    "        self.seed = 1\n",
    "        self.hidden_dim = 256\n",
    "        self.lr = 3e-4\n",
    "        self.n_steps = 200\n",
    "        self.mini_batch_size = 50\n",
    "        self.n_epochs = 4\n",
    "        self.threshold_reward = -200\n",
    "        self.clip_param = 0.2\n",
    "        self.gamma = 0.95\n",
    "        self.tau = 0.95\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 两种advantage的对比\n",
    "\n",
    "计算advantage的通常有两种方式，如下：\n",
    "1. 蒙特卡洛计算，returns - values，即$A(s,a) = G_t - V(s)$\n",
    "2. TD error，即$A(s,a) = R_{t+1} + \\gamma V(S_{t+1}) - V(S_t)$，或者GAE的形式，即$A(s,a) = \\sum_{l=0}^{\\infty}(\\gamma \\lambda)^l \\delta_{t+l}^{V}$\n",
    "\n",
    "这两种方式的对比如下：\n",
    "1. 前者即MC的方式，是无偏估计，但是方差较大，因为returns是一个随机变量，而values是一个确定的值，所以两者相减会增大方差，后者是有偏估计，但是方差较小，因为TD error是一个确定的值，所以方差较小\n",
    "2. 前者计算简单，后者计算复杂，因为后者需要计算TD error，而TD error需要计算V(s)，所以需要一个额外的网络来计算V(s)\n",
    "3. 前者适合离散动作，后者适合连续动作，因为前者需要计算returns，而returns是一个随机变量，所以需要多次采样，而后者只需要计算TD error，所以只需要一次采样\n",
    "4. 前者适合需要完整的序列，后者适合需要连续更新并降低方差以加速训练的情况，例如PPO等\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MC计算advantage效果\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cfg = Config()\n",
    "all_seed(cfg.seed)\n",
    "env = create_vecenv(cfg.env_id, n_envs = cfg.n_envs)\n",
    "test_env = gym.make(cfg.env_id)\n",
    "setattr(cfg, \"action_space\", test_env.action_space)\n",
    "setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "setattr(cfg, \"action_dim\", env.action_space.shape[0])\n",
    "policy = Policy(cfg)\n",
    "\n",
    "frame_idx  = 0\n",
    "test_rewards = []\n",
    "test_frames = []\n",
    "update_steps = []\n",
    "update_idx = 0\n",
    "actor_losses = []\n",
    "critic_losses = []\n",
    "state = env.reset()\n",
    "early_stop = False\n",
    "\n",
    "while frame_idx < cfg.max_frames and not early_stop:\n",
    "\n",
    "    log_probs = []\n",
    "    values    = []\n",
    "    states    = []\n",
    "    actions   = []\n",
    "    rewards   = []\n",
    "    masks     = []\n",
    "    entropy = 0\n",
    "\n",
    "    for _ in range(cfg.n_steps):\n",
    "        action, log_prob, value = policy.get_action(state)\n",
    "        next_state, reward, terminated, truncated, _ = env.step(action)\n",
    "\n",
    "        log_probs.append(log_prob)\n",
    "        values.append(value)\n",
    "        rewards.append(torch.FloatTensor(reward).unsqueeze(1).to(cfg.device))\n",
    "        masks.append(torch.FloatTensor(1 - truncated).unsqueeze(1).to(cfg.device))\n",
    "        \n",
    "        states.append(torch.tensor(state, dtype=torch.float, device=cfg.device))\n",
    "        actions.append(torch.tensor(action, dtype=torch.float, device=cfg.device))\n",
    "        \n",
    "        state = next_state\n",
    "        frame_idx += 1\n",
    "        if frame_idx % 500 == 0:\n",
    "            test_reward = np.mean([evaluate_policy(test_env, policy) for _ in range(10)])\n",
    "            test_rewards.append(test_reward)\n",
    "            test_frames.append(frame_idx)\n",
    "            # print(f\"Frame {frame_idx}. Mean reward: {test_reward}\")\n",
    "            plot_rewards(test_frames, test_rewards, device = cfg.device)\n",
    "            if test_reward > cfg.threshold_reward: early_stop = True\n",
    "        \n",
    "    next_state = torch.FloatTensor(next_state).to(cfg.device)\n",
    "    _, _, next_value = policy.model(next_state)\n",
    "    returns = policy.compute_return_mc(rewards, masks)\n",
    "\n",
    "    returns   = torch.cat(returns).detach()\n",
    "    log_probs = torch.cat(log_probs).detach()\n",
    "    values    = torch.cat(values).detach()\n",
    "    states    = torch.cat(states) \n",
    "    actions   = torch.cat(actions)\n",
    "    advantage = returns - values\n",
    "    actor_loss, critic_loss = policy.learn(states=states, actions=actions, log_probs=log_probs, returns=returns, advantages=advantage)\n",
    "    update_idx += 1\n",
    "    update_steps.append(update_idx)\n",
    "    actor_losses.append(actor_loss)\n",
    "    critic_losses.append(critic_loss)\n",
    "\n",
    "env.close()\n",
    "test_env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_losses(update_steps, actor_losses, cfg.device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_losses(update_steps, critic_losses, cfg.device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TD计算advantage的效果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cfg = Config()\n",
    "all_seed(cfg.seed)\n",
    "env = create_vecenv(cfg.env_id, n_envs = cfg.n_envs)\n",
    "test_env = gym.make(cfg.env_id)\n",
    "setattr(cfg, \"action_space\", test_env.action_space)\n",
    "setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "setattr(cfg, \"action_dim\", env.action_space.shape[0])\n",
    "policy = Policy(cfg)\n",
    "\n",
    "frame_idx  = 0\n",
    "test_rewards = []\n",
    "test_frames = []\n",
    "update_steps = []\n",
    "update_idx = 0\n",
    "actor_losses = []\n",
    "critic_losses = []\n",
    "state = env.reset()\n",
    "early_stop = False\n",
    "\n",
    "while frame_idx < cfg.max_frames and not early_stop:\n",
    "\n",
    "    log_probs = []\n",
    "    values    = []\n",
    "    states    = []\n",
    "    actions   = []\n",
    "    rewards   = []\n",
    "    masks     = []\n",
    "    entropy = 0\n",
    "\n",
    "    for _ in range(cfg.n_steps):\n",
    "        action, log_prob, value = policy.get_action(state)\n",
    "        next_state, reward, terminated, truncated, _ = env.step(action)\n",
    "\n",
    "        log_probs.append(log_prob)\n",
    "        values.append(value)\n",
    "        rewards.append(torch.FloatTensor(reward).unsqueeze(1).to(cfg.device))\n",
    "        masks.append(torch.FloatTensor(1 - truncated).unsqueeze(1).to(cfg.device))\n",
    "        \n",
    "        states.append(torch.tensor(state, dtype=torch.float, device=cfg.device))\n",
    "        actions.append(torch.tensor(action, dtype=torch.float, device=cfg.device))\n",
    "        \n",
    "        state = next_state\n",
    "        frame_idx += 1\n",
    "        if frame_idx % 500 == 0:\n",
    "            test_reward = np.mean([evaluate_policy(test_env, policy) for _ in range(10)])\n",
    "            test_rewards.append(test_reward)\n",
    "            test_frames.append(frame_idx)\n",
    "            # print(f\"Frame {frame_idx}. Mean reward: {test_reward}\")\n",
    "            plot_rewards(test_frames, test_rewards, device = cfg.device)\n",
    "            if test_reward > cfg.threshold_reward: early_stop = True\n",
    "        \n",
    "    next_state = torch.FloatTensor(next_state).to(cfg.device)\n",
    "    _, _, next_value = policy.model(next_state)\n",
    "    returns = policy.compute_advantage_td(rewards, masks, values)\n",
    "\n",
    "    returns   = torch.cat(returns).detach()\n",
    "    log_probs = torch.cat(log_probs).detach()\n",
    "    values    = torch.cat(values).detach()\n",
    "    states    = torch.cat(states) \n",
    "    actions   = torch.cat(actions)\n",
    "    advantage = returns - values\n",
    "    actor_loss, critic_loss = policy.learn(states=states, actions=actions, log_probs=log_probs, returns=returns, advantages=advantage)\n",
    "    update_idx += 1\n",
    "    update_steps.append(update_idx)\n",
    "    actor_losses.append(actor_loss)\n",
    "    critic_losses.append(critic_loss)\n",
    "env.close()\n",
    "test_env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_losses(update_steps, actor_losses, cfg.device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_losses(update_steps, critic_losses, cfg.device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GAE计算advantage效果\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cfg = Config()\n",
    "all_seed(cfg.seed)\n",
    "env = create_vecenv(cfg.env_id, n_envs = cfg.n_envs)\n",
    "test_env = gym.make(cfg.env_id)\n",
    "setattr(cfg, \"action_space\", test_env.action_space)\n",
    "setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "setattr(cfg, \"action_dim\", env.action_space.shape[0])\n",
    "policy = Policy(cfg)\n",
    "\n",
    "frame_idx  = 0\n",
    "test_rewards = []\n",
    "test_frames = []\n",
    "update_steps = []\n",
    "update_idx = 0\n",
    "actor_losses = []\n",
    "critic_losses = []\n",
    "state = env.reset()\n",
    "early_stop = False\n",
    "\n",
    "while frame_idx < cfg.max_frames and not early_stop:\n",
    "\n",
    "    log_probs = []\n",
    "    values    = []\n",
    "    states    = []\n",
    "    actions   = []\n",
    "    rewards   = []\n",
    "    masks     = []\n",
    "    entropy = 0\n",
    "\n",
    "    for _ in range(cfg.n_steps):\n",
    "        action, log_prob, value = policy.get_action(state)\n",
    "        next_state, reward, terminated, truncated, _ = env.step(action)\n",
    "\n",
    "        log_probs.append(log_prob)\n",
    "        values.append(value)\n",
    "        rewards.append(torch.FloatTensor(reward).unsqueeze(1).to(cfg.device))\n",
    "        masks.append(torch.FloatTensor(1 - truncated).unsqueeze(1).to(cfg.device))\n",
    "        \n",
    "        states.append(torch.tensor(state, dtype=torch.float, device=cfg.device))\n",
    "        actions.append(torch.tensor(action, dtype=torch.float, device=cfg.device))\n",
    "        \n",
    "        state = next_state\n",
    "        frame_idx += 1\n",
    "        if frame_idx % 500 == 0:\n",
    "            test_reward = np.mean([evaluate_policy(test_env, policy) for _ in range(10)])\n",
    "            test_rewards.append(test_reward)\n",
    "            test_frames.append(frame_idx)\n",
    "            # print(f\"Frame {frame_idx}. Mean reward: {test_reward}\")\n",
    "            plot_rewards(test_frames, test_rewards, device = cfg.device)\n",
    "            if test_reward > cfg.threshold_reward: early_stop = True\n",
    "        \n",
    "    next_state = torch.FloatTensor(next_state).to(cfg.device)\n",
    "    _, _, next_value = policy.model(next_state)\n",
    "    # returns = policy.compute_monte_carlo_advantage(rewards, masks, values)\n",
    "    returns = policy.compute_advantage_gae(next_value, rewards, masks, values)\n",
    "\n",
    "    returns   = torch.cat(returns).detach()\n",
    "    log_probs = torch.cat(log_probs).detach()\n",
    "    values    = torch.cat(values).detach()\n",
    "    states    = torch.cat(states) \n",
    "    actions   = torch.cat(actions)\n",
    "    advantage = returns - values\n",
    "    actor_loss, critic_loss = policy.learn(states=states, actions=actions, log_probs=log_probs, returns=returns, advantages=advantage)\n",
    "    update_idx += 1\n",
    "    update_steps.append(update_idx)\n",
    "    actor_losses.append(actor_loss)\n",
    "    critic_losses.append(critic_loss)\n",
    "env.close()\n",
    "test_env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_losses(update_steps, actor_losses, cfg.device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_losses(update_steps, critic_losses, cfg.device)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl-book",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
